1. Technical Field
This disclosure concerns analyzing the features of a product line and determining permissible feature configurations.
2. Background Information
A feature configuration analysis tool allows vendors to offer customizable products to consumers. For example, many software vendors base the price of an application on the features delivered, and consider a feature as an end-user-visible characteristic of a system describing a unit of functionality. A vendor selling an email client program may charge more when the program includes a cryptographic feature. Software vendors prefer to ship applications with entire sets of features to customers and it economically infeasible to ship a different version of an application every time a customer wants a new configuration. Customers switch between different configurations of an application (e.g., sets of features) by employing software vendor provided configuration codes during installation and upgrade of an application. The configuration codes activate the ordered features, and/or alternatively, deactivate features.
The potential market for a product line (e.g., an application) expands when features (e.g., services) can be easily added and removed from a configuration (e.g., application), because customers can order configurations that fit their budgets. Configurations may be produced based on the system requirements needed to support the complexity of a configuration, cost sensitivity of the consumer, and the amount of revenue generated by a configuration.
Determining the permissibility of a requested feature configuration (e.g., compatibility of features) may be easy when a product or a service (e.g., model-T Ford automobile) includes a small number of features. However, large-scale product lines include hundreds of features, transforms the technical challenge into a nondeterministic polynomial-time hard (NP-hard) type of problem. When a developer uses propositional logic formulae (PLF) to express constraints on a product line, the developer may consider using a SAT solver to analyze possible solutions until the SAT solver identifies a solution that satisfies the constraints and includes the desired features. Even using the best SAT solvers may require hours to verify the permissibility of a feature configuration, because the heuristics that SAT solvers use do not guarantee quick and complete results. Commercial-strength large-scale software systems find delays in the decision making process unacceptable, especially when consumers use such systems to complete on-line purchases. For example, consumers often evaluate options and prices before making a decision to order a particular configuration. Consumers often have a key set of features in mind when buying any product or service (e.g., computer or a car). For example, a computer retailer web site may offer a wide variety of features that consumers may choose from to include in the configuration of a computer. Even so, some features maybe incompatible with the others. When a consumer selects incompatible features a message appears to inform the customer regarding the incorrect selection (e.g., a particular video card may be incompatible with a particular monitor).
In one implementation, a feature configuration tool may be used by a developer to create dynamically reconfigurable applications (DRAs). When creating applications, developers concentrate on designing and implementing core functionality and delivering an evaluation version of an application with a finite set of features to customers. Customers evaluate the application and identify a desired set of features. Because developers find it difficult to anticipate the features that a customer will want prior to the evaluation may be one reason that the development process proceeds in this manner. Accordingly, developers often choose to transform applications into DRAs after a particular period of time has lapsed following application deployment. Even so, developers find it challenging to design and implement DRAs because of the complexity involved in building DRAs. Developers currently build DRAs employing a tedious, intrusive, manual and error-prone method of searching for uses of variables that represent reconfigurable features in application logic, and replacing the variables with fragments of code that handle the deactivated, and customized states of the replaced variables.
Transforming applications into DRAs using current methods requires developers to identify application features in the logic, and logical collections of application variables (i.e., objects) and types (e.g., methods, classes, and interfaces) that represent the features. Modifying existing logic to add feature deactivation and customized functionality can be viewed as unplugging variables corresponding to features from a tree that represents the application and replacing the unplugged variables with fragments of code to handle activation, deactivation, or modification of functionality involving those variables that match the unplugged variables. Activating, deactivating and customizing alternative functionality for features requires developers to analyze how states of DRAs change (e.g., the properties of DRAs) and influence the properties of an application. The complexity of DRAs makes it difficult to verify the properties of DRAs. Organizations find current methods of transforming applications into DRAs expensive, difficult to effectively verify the correctness of the DRAs produced, and often lead to DRAs with bugs (e.g., application run-time errors).
Highly specialized solutions have evolved that employ frameworks that provide basic dynamic reconfiguration services for various types of applications, including: component-based, distributed, grid, and high-performance applications. Few of the specialized solutions verify the DRAs produced by the frameworks because of the complexity of the frameworks. Among the frameworks, conceptual frameworks describe architecture models for dynamic reconfiguration (e.g., Extensible Coordination Framework (ECF)) that enable developers to design DRAs as graphs and compile the graphs and extension modules into a resulting executable of a DRA. Mastering such frameworks requires a steep learning curve for developers, making it difficult to maintain and evolve the DRAs resulting from using such frameworks.
Developers may also use solutions that employ special system services provided by operating systems and different execution platforms to add and remove applications features. Such solutions inherently include unavoidable performance penalties because adding reconfiguration enabled special services requires changes to the kernels of underlying operating systems, component platforms, and virtual machines. Developers find such solutions challenging to implement and analyze for consistency with the legacy application properties (e.g., run-time behaviour). Most of the formal research directed to methods for developing DRAs focus on distributed systems that employ different formalisms to represent computations at a low level, but often the computations do not scale to large DRAs.
The extraordinary technical challenges associated with determining permissible feature configurations are evident in that all of the previously mentioned techniques of analyzing the permissibility of a feature configuration perform poorly in comparison to the feature configuration tool.
A need has long existed for a system and method that addresses the feature configuration analysis problems noted above, and rapidly verifies the permissibility of a feature configuration.